import { invoke } from '@tauri-apps/api/core';

/**
 * 安全存储服务
 * 使用 Tauri 的文件系统 API 将数据存储在应用数据目录中
 * 比 localStorage 更安全，因为数据存储在应用专用目录中
 */

/**
 * 存储数据
 */
export const secureStoreSet = async (key: string, value: string): Promise<void> => {
  try {
    await invoke('secure_store_set', { key, value });
  } catch (error) {
    console.error('安全存储失败:', error);
    throw error;
  }
};

/**
 * 读取数据
 */
export const secureStoreGet = async (key: string): Promise<string | null> => {
  try {
    const result = await invoke<string | null>('secure_store_get', { key });
    return result;
  } catch (error) {
    console.error('安全读取失败:', error);
    return null;
  }
};

/**
 * 删除数据
 */
export const secureStoreRemove = async (key: string): Promise<void> => {
  try {
    await invoke('secure_store_remove', { key });
  } catch (error) {
    console.error('安全删除失败:', error);
    throw error;
  }
};

/**
 * 清理所有聊天记录
 */
export const clearAllChatMessages = async (): Promise<void> => {
  try {
    await invoke('clear_all_chat_messages');
  } catch (error) {
    console.error('清理聊天记录失败:', error);
    throw error;
  }
};

/**
 * 清理特定用户的聊天记录
 */
export const clearUserChatMessages = async (userId: string): Promise<void> => {
  try {
    await invoke('clear_user_chat_messages', { userId });
  } catch (error) {
    console.error('清理用户聊天记录失败:', error);
    throw error;
  }
};

/**
 * 清理特定群组的本地聊天记录
 * @returns 删除的消息数量
 */
export const clearGroupChatMessages = async (groupId: string): Promise<number> => {
  try {
    const deletedCount = await invoke<number>('clear_group_chat_messages', { groupId });
    return deletedCount;
  } catch (error) {
    console.error('清理群组聊天记录失败:', error);
    throw error;
  }
};

/**
 * 检查是否在 Tauri 环境中
 */
export const isTauri = (): boolean => {
  return typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
};

/**
 * 获取或生成实例 ID（用于区分不同的 Tauri 实例）
 * 每个 Tauri 实例在启动时会生成一个唯一的实例 ID
 */
let instanceId: string | null = null;

export const getInstanceId = (): string => {
  if (instanceId) {
    return instanceId;
  }
  
  // 尝试从 localStorage 读取（如果之前已经生成过）
  if (typeof window !== 'undefined' && 'localStorage' in window) {
    const stored = localStorage.getItem('_tauri_instance_id');
    if (stored) {
      instanceId = stored;
      return instanceId;
    }
  }
  
  // 生成新的实例 ID（基于时间戳和随机数）
  instanceId = `instance_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
  
  // 保存到 localStorage（仅用于当前会话）
  if (typeof window !== 'undefined' && 'localStorage' in window) {
    localStorage.setItem('_tauri_instance_id', instanceId);
  }
  
  console.log('生成新的 Tauri 实例 ID:', instanceId);
  return instanceId;
};

/**
 * 在存储键名中添加实例 ID 前缀（仅 Tauri 环境）
 * 这样不同的 Tauri 实例可以使用独立的存储空间
 */
const addInstancePrefix = (key: string): string => {
  if (isTauri()) {
    const instanceId = getInstanceId();
    return `${instanceId}_${key}`;
  }
  return key;
};

// 为了兼容性，在 Tauri 环境中同时更新 localStorage 作为缓存
// 这样同步函数可以快速读取，异步函数可以读取最新数据
const syncToLocalStorage = async (key: string, value: string | null) => {
  if (isTauri() && typeof window !== 'undefined' && 'localStorage' in window) {
    if (value === null) {
      localStorage.removeItem(key);
    } else {
      localStorage.setItem(key, value);
    }
  }
};

/**
 * 兼容性存储：在 Tauri 环境中使用安全存储，否则使用 localStorage
 * 在 Tauri 环境中，会自动添加实例 ID 前缀，使不同实例使用独立存储
 */
export const storageSet = async (key: string, value: string): Promise<void> => {
  if (isTauri()) {
    const instanceKey = addInstancePrefix(key);
    await secureStoreSet(instanceKey, value);
    // 同时更新 localStorage 作为缓存，方便同步读取（使用原始 key）
    await syncToLocalStorage(key, value);
  } else {
    localStorage.setItem(key, value);
  }
};

/**
 * 兼容性读取：在 Tauri 环境中使用安全存储，否则使用 localStorage
 * 在 Tauri 环境中，会自动添加实例 ID 前缀
 */
export const storageGet = async (key: string): Promise<string | null> => {
  if (isTauri()) {
    const instanceKey = addInstancePrefix(key);
    return await secureStoreGet(instanceKey);
  } else {
    return localStorage.getItem(key);
  }
};

/**
 * 兼容性删除：在 Tauri 环境中使用安全存储，否则使用 localStorage
 * 在 Tauri 环境中，会自动添加实例 ID 前缀
 */
export const storageRemove = async (key: string): Promise<void> => {
  if (isTauri()) {
    const instanceKey = addInstancePrefix(key);
    await secureStoreRemove(instanceKey);
    // 同时删除 localStorage 缓存（使用原始 key）
    await syncToLocalStorage(key, null);
  } else {
    localStorage.removeItem(key);
  }
};

/**
 * 获取 token（兼容 Tauri 和浏览器环境）
 * 这是一个同步函数，优先从 localStorage 缓存读取（在 Tauri 环境中，登录时会同步更新 localStorage）
 * 如果需要异步版本，请使用 storageGet('token')
 */
export const getToken = (): string | null => {
  return localStorage.getItem('token');
};

/**
 * 获取 token（异步版本，从安全存储读取）
 * 在 Tauri 环境中，这会从安全存储读取最新的 token
 */
export const getTokenAsync = async (): Promise<string | null> => {
  if (isTauri()) {
    return await storageGet('token');
  } else {
    return localStorage.getItem('token');
  }
};

/**
 * 清理所有缓存数据（Tauri 环境）
 * 删除应用数据目录下的所有文件，包括聊天记录、群组缓存、用户数据等
 */
export const clearAllCache = async (): Promise<number> => {
  if (!isTauri()) {
    // 浏览器环境，清理 localStorage
    localStorage.clear();
    return 0;
  }
  
  try {
    const { invoke } = await import('@tauri-apps/api/core');
    const deletedCount = await invoke<number>('clear_all_cache');
    // 同时清理 localStorage（作为缓存）
    localStorage.clear();
    return deletedCount;
  } catch (error) {
    console.error('清理缓存失败:', error);
    throw error;
  }
};

